ChucK  è , come indicato sul suo sito," un linguaggio di programmazione audio per sintesi , composizione, ed esecuzione  in tempo reale - pienamente supportato su MacOSX, Windows e Linux. ChucK presenta nuovo modello di programmazione bassato sul tempo e concorrente altamente preciso ed espressivo (lo chiamiamo fortemente-temporizzato), un buon livello di controllo dinamico, e l'abilità di aggiungere e modificare al volo. In più, ChucK supporta dispositivi MIDI, OSC, HID, e audio multi canale."

ChucK è estremamente votato alla sperimentazione con sintesi audio e MIDI, ma anche uno strumento potente per  esecuzioni dal vivo.  Questo articolo è un'introduzione all'utilizzo di questo incredibile mezzo e alla sua semplicità di apprendimento. Per provare tutto ciò svilupperemo un semplice arpeggiatore MIDI in poche righe di codice. Lo scopo della serie completa di articoli sarà di costruire una sorta di piattaforma da utilizzare dal vivo o per sperimentazione. 

Dò per scontato che ChucK sia già installato, non importa se da binari o sorgente e che sia già stato testato con uno degli esempi inclusi nella distribuzione. Una nota; lavoro su Linux per cui la sezione seguente circa gli strumenti da usare è un pò specifica per il sistema operativo. Gli utenti Windows/MacOSX non si preoccupino, perchè ChucK è pienamente compatibile con i loro sistemi, e il resto dell'articolo è indipendente dalla piattaforma.

Utilizzeremo una configurazione software molto semplice. Suggerisco fortemente di usare Jack su alsa, e detto ciò ecco cosa ci serve:

• Jack (ChucK supporta oss e alsa)
• qjackctl, un'interfaccia grafica per controllare Jack
• ChucK, ovviamente, compilato per il vostro sistema audio
• un sintetizzatore software con supporto MIDI (ZynAddSubFx è favoloso, soprattutto per sperimentare)
• A tastiera MIDI virtuale (vkeybd ad esempio)

Se già fate musica al computer probabilmente avrete già tutti questi strumenti(e molti altri). Queli suggeriti sono disponibili sulla maggior parte delle distribuzioni Linux senza dover compilare nulla. Naturalmente, se avete esperienza potete usare i software che più vi aggradino, io dò solo alcune linee guida per aiutare i meno esperti. 

Ora, lanciate qjackctl, zynaddsubfx e vkeybd.
Il prossimo passo è di lanciare la macchina virtuale (VM) di ChucK. Da riga di comando:

chuck --loop &

Questo istanzierà la VM e la metterà in attesa di comandi. I successivi comandi verranno eseguiti sulla VM attiva.

C'è ancora una cosa da fare, connettere l'uscita audio di ZynAddSubFX al nostro dispositivo alsa_pcm (se non lo è già). Lo facciamo dal pannello "Connection" di qjackctl che, fatto ciò, apparirà più o meno così: 

dove:

• alsa_pcm sul pannello a sinistra è il nostro dispositivo di ingresso, ad es. un microfono(ignoriamolo per ora)
• alsa_pcm sul pannello a destra è il nostro dispositivo di uscita(altoparlanti o cuffie)
• RtApiJack sul lpannello a sinistra è la porta di ingresso di ChucK
• RtApiJack sul pannello a detra è la porta di uscita di ChucK
• ZynAddSubFX sul pannello di sinistra è la porta di uscita del nostro sintetizzatore software

ChucK  è un linguaggio orientato agli oggetti, ed include molti utili oggetti pronti da impiegare. Dobbiamo costruire un arpeggiatore MIDI, per cui i primi oggetti che ci servono sono relativi al MIDI. Il comportamento del nostro arpeggiatore sarà il seguente: alla pressione di un tasto sulla tastiera midi, il corrispondente evento midi(note-on) verrà catturato dal programma, che comporrà un arpeggio (utilizando una lista di differenze tonali). La sequenza di note creata verrà rediretta al sintetizzatore software per essere suonata. Cercherò di mantenere il codice il più semplice possibile per focalizzarci solo sui concetti cardine. Apriamo il nostro editor di testo preferito, o lo sperimentale miniAudicle(reperibile dal sito di ChucK) ed iniziamo a scrivere codice:

MidiIn min;
MidiOut mout;
MidiMsg msg;

Abbiamo appena definito un dispositivo MIDI di ingresso(min), uno di uscita(mout) ed un oggetto messagio MIDI (msg). Ora dobbiamo "aprire" il nostro dispositivo MIDI,mediante il metodo open , che accetta come argomento un numero di dispositivo. Per conoscere il numero di dispositivo che ci interessa, sulla riga di comando scriviamo:

    chuck --probe

Nel mio caso otterrò come risultato:

[chuck]: ------( chuck -- 2 MIDI inputs )------
[chuck]:     [0] : "Midi Through Port-0"
[chuck]:     [1] : "Virtual Keyboard"
[chuck]:
[chuck]: ------( chuck -- 2 MIDI outputs )-----
[chuck]:     [0] : "Midi Through Port-0"
[chuck]:     [1] : "ZynAddSubFX"

 I numeri in parentesi quadre sono esattamente quello di cui abbiamo bisogno. Quindi il mio dispositivo MIDI di ingresso , "Virtual Keyboard", ha indicativo "1", idem per il mio dispositivo MIDI di uscita "ZunAddSubFX". A questo punto le prossime rige di codice:

min.open(1);
mout.open(1);

Ora che i nostri canali MIDI sono aperti, dobbiamo gestire i messaggi in arrivo dal nostro dispositivo MIDI  di ingresso (nel nostro caso la tastiera virtuale).Faremo partire un ciclo infinito che attenda messaggi in ingresso, li processi e torni in attesa indefinitamente.

while(true){
	min => now;
	min.recv(msg);
	if(msg.data1 == 144){
		spork ~ arpeggio(msg);
	}
}

01:	fun void arpeggio(MidiMsg mymsg){
02:		MidiMsg message;
03:		mymsg.data1 => message.data1;
04:		mymsg.data2 => message.data2;
05:		mymsg.data3 => message.data3;
06:	
07:		[0,4,3,4,5,-5,-4,-3] @=>  int scale[];
08:		for ( 0 => int i; i < scale.cap();  i++){
09:			144 => message.data1;
10:			scale[i] +=> message.data2;
11:			mout.send(message);
12:			300::ms => now;
13:			128 => message.data1;
14:			mout.send(message);
15:		}
16:	}

[chuck](VM): sporking incoming shred: 1 (arpeggiator.ck)...